import { http } from '@/utils/request'

// ==================== 工具函数 ====================
/**
 * 过滤掉对象中的空值 (null, undefined, 空字符串)
 * @param {Object} params - 需要过滤的参数对象
 * @returns {Object} 过滤后的参数对象
 */
const filterEmptyValues = (params = {}) => {
  const filteredParams = { ...params }
  Object.keys(filteredParams).forEach((key) => {
    if (filteredParams[key] === '' || filteredParams[key] === null || filteredParams[key] === undefined) {
      delete filteredParams[key]
    }
  })
  return filteredParams
}

/**
 * 验证参数是否在允许的值列表中
 * @param {any} value - 要验证的值
 * @param {Array} allowedValues - 允许的值列表
 * @param {string} paramName - 参数名称 (用于错误信息)
 * @returns {boolean} 验证是否通过
 * @throws {Error} 如果验证失败
 */
const validateEnum = (value, allowedValues, paramName) => {
  if (value && !allowedValues.includes(value)) {
    throw new Error(`${paramName}必须是 ${allowedValues.join('、')} 之一`)
  }
  return true
}

/**
 * 验证 ID 参数
 * @param {number|string} id - ID值
 * @param {string} idName - ID名称 (用于错误信息)
 * @throws {Error} 如果ID为空
 */
const validateId = (id, idName) => {
  if (!id) {
    throw new Error(`${idName}不能为空`)
  }
}

/**
 * 验证操作类型
 * @param {string} action - 操作类型
 * @param {Array} allowedActions - 允许的操作类型
 * @throws {Error} 如果操作类型无效
 */
const validateAction = (action, allowedActions) => {
  if (!allowedActions.includes(action)) {
    throw new Error(`操作类型必须是 ${allowedActions.join(' 或 ')}`)
  }
}

/**
 * 合并默认参数并过滤空值
 * @param {Object} defaultParams - 默认参数对象
 * @param {Object} userParams - 用户提供的参数对象
 * @returns {Object} 合并并过滤后的参数对象
 */
const mergeParams = (defaultParams, userParams = {}) => {
  return filterEmptyValues({ ...defaultParams, ...userParams })
}

// ==================== 请求参数处理函数 ====================

/**
 * 处理电视剧列表请求参数
 * @param {Object} params - 用户提供的参数
 * @returns {Object} 处理后的参数
 */
const handleDramaListParams = (params = {}) => {
  const defaultParams = {
    page: 1,
    pageSize: 10,
    category: 'all',
    keyword: ''
  }

  return mergeParams(defaultParams, params)
}

/**
 * 处理电视剧集数列表请求参数
 * @param {Object} params - 用户提供的参数
 * @returns {Object} 处理后的参数
 */
const handleEpisodesParams = (params = {}) => {
  const defaultParams = {
    sort: 'asc',
    status: 'all'
  }

  const finalParams = mergeParams(defaultParams, params)

  // 参数验证
  validateEnum(finalParams.sort, ['asc', 'desc'], '排序方式')
  validateEnum(finalParams.status, ['all', 'available', 'coming'], '筛选状态')

  return finalParams
}

/**
 * 处理追剧列表请求参数
 * @param {Object} params - 用户提供的参数
 * @returns {Object} 处理后的参数
 */
const handleFollowingParams = (params = {}) => {
  const defaultParams = {
    page: 1,
    pageSize: 10,
    sort: 'follow_time',
    status: 'all'
  }

  const finalParams = mergeParams(defaultParams, params)

  // 参数验证
  validateEnum(finalParams.sort, ['follow_time', 'update_time'], '排序方式')
  validateEnum(finalParams.status, ['all', 'updating', 'completed'], '筛选状态')

  return finalParams
}

/**
 * 处理分类电视剧请求参数
 * @param {Object} params - 用户提供的参数
 * @returns {Object} 处理后的参数
 */
const handleCategoryParams = (params = {}) => {
  const defaultParams = {
    page: 1,
    pageSize: 10,
    dramaCount: 10
  }

  return mergeParams(defaultParams, params)
}

/**
 * 处理精选视频请求参数
 * @param {Object} params - 用户提供的参数
 * @returns {Object} 处理后的参数
 */
const handleFeaturedParams = (params = {}) => {
  const defaultParams = {
    page: 1,
    pageSize: 15,
    sortBy: 'comprehensive',
    timeRange: 'all'
  }

  const finalParams = mergeParams(defaultParams, params)

  // 参数验证
  validateEnum(finalParams.sortBy, ['like', 'favorite', 'comment', 'comprehensive'], '排序方式')
  validateEnum(finalParams.timeRange, ['all', 'week', 'month'], '时间范围')

  return finalParams
}

/**
 * 处理我的追剧列表请求参数
 * @param {Object} params - 用户提供的参数
 * @returns {Object} 处理后的参数
 */
const handleMyFollowingParams = (params = {}) => {
  const defaultParams = {
    page: 1,
    pageSize: 10,
    sort: 'follow_time',
    status: 'all'
  }

  const finalParams = mergeParams(defaultParams, params)

  // 参数验证
  validateEnum(finalParams.sort, ['follow_time', 'update_time', 'watch_progress'], '排序方式')
  validateEnum(finalParams.status, ['all', 'updating', 'completed', 'has_update'], '筛选状态')

  return finalParams
}

/**
 * 处理浏览记录请求参数
 * @param {Object} params - 用户提供的参数
 * @returns {Object} 处理后的参数
 */
const handleBrowsingHistoryParams = (params = {}) => {
  const defaultParams = {
    page: 1,
    pageSize: 20,
    sort: 'watch_time',
    timeRange: 'all'
  }

  const finalParams = mergeParams(defaultParams, params)

  // 参数验证
  validateEnum(finalParams.sort, ['watch_time', 'drama_title'], '排序方式')
  validateEnum(finalParams.timeRange, ['all', 'today', 'week', 'month'], '时间范围')

  return finalParams
}

/**
 * 处理点赞电视剧请求参数
 * @param {Object} params - 用户提供的参数
 * @returns {Object} 处理后的参数
 */
const handleLikedDramasParams = (params = {}) => {
  const defaultParams = {
    page: 1,
    pageSize: 10,
    sort: 'like_time',
    likeType: 'all'
  }

  const finalParams = mergeParams(defaultParams, params)

  // 参数验证
  validateEnum(finalParams.sort, ['like_time', 'drama_title', 'update_time'], '排序方式')
  validateEnum(finalParams.likeType, ['all', 'drama', 'episode'], '点赞类型')

  return finalParams
}

/**
 * 处理用户收藏列表请求参数
 * @param {Object} params - 用户提供的参数
 * @returns {Object} 处理后的参数
 */
const handleUserFavoritesParams = (params = {}) => {
  const defaultParams = {
    page: 1,
    pageSize: 10,
    sort: 'favorite_time',
    favoriteType: 'all'
  }

  const finalParams = mergeParams(defaultParams, params)

  // 参数验证
  validateEnum(finalParams.sort, ['favorite_time', 'drama_title', 'update_time'], '排序方式')
  validateEnum(finalParams.favoriteType, ['all', 'drama', 'episode'], '收藏类型')

  return finalParams
}

/**
 * 处理主页标签数据请求参数
 * @param {string} tabKey - 标签标识
 * @param {Object} params - 用户提供的参数
 * @returns {Object} 处理后的参数和请求配置
 */
const handleHomeTabParams = (tabKey, params = {}) => {
  if (!tabKey) {
    throw new Error('标签标识不能为空')
  }

  const validTabs = ['recommend', 'ranking', 'newDrama', 'classic']
  validateEnum(tabKey, validTabs, '标签标识')

  // 设置默认参数
  const defaultParams = {
    page: 1,
    pageSize: 20,
    withPagination: false
  }

  const finalParams = mergeParams(defaultParams, params)

  // 验证推荐分类
  if (tabKey === 'recommend' && finalParams.category) {
    const validRecommendCategories = ['featured', 'costume', 'rebirth', 'family', 'romance', 'timetravel']
    validateEnum(finalParams.category, validRecommendCategories, '推荐分类')
  }

  // 验证排行榜分类
  if (tabKey === 'ranking' && finalParams.category) {
    const validRankingCategories = ['hot', 'rising', 'new', 'trending']
    validateEnum(finalParams.category, validRankingCategories, '排行榜分类')
  }

  // 根据参数决定使用哪个API端点
  if (finalParams.withPagination || finalParams.category) {
    return {
      url: `/api/home/tabs/${tabKey}/page`,
      params: finalParams
    }
  }

  return {
    url: `/api/home/tabs/${tabKey}`,
    params: {}
  }
}

// ==================== API 函数 ====================

/**
 * 1. 获取电视剧列表
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回电视剧列表和分页信息
 */
export const reqDramaList = (params = {}) => {
  return http.get('/api/dramas', { params: handleDramaListParams(params) })
}

/**
 * 2. 获取电视剧详情（包含所有集数）
 * @param {number|string} dramaId - 电视剧ID
 * @returns {Promise} 返回电视剧详细信息和集数列表
 */
export const reqDramaDetail = (dramaId) => {
  validateId(dramaId, '电视剧ID')
  return http.get(`/api/dramas/${dramaId}`)
}

/**
 * 3. 获取单集详情
 * @param {number|string} dramaId - 电视剧ID
 * @param {number|string} episodeId - 集数ID
 * @returns {Promise} 返回单集详细信息
 */
export const reqEpisodeDetail = (dramaId, episodeId) => {
  validateId(dramaId, '电视剧ID')
  validateId(episodeId, '集数ID')
  return http.get(`/api/dramas/${dramaId}/episodes/${episodeId}`)
}

/**
 * 获取单集评论列表
 * @param {number|string} episodeId - 集数ID
 * @param {Object} params - 查询参数
 * @param {number} params.page - 页码，默认1
 * @param {number} params.pageSize - 每页数量，默认20
 * @param {string} params.sort - 排序方式，可选值：'newest'最新/'hottest'最热，默认'newest'
 * @param {boolean} params.showSpoilers - 是否显示含有剧透的评论，默认false
 * @returns {Promise} 返回单集评论列表
 */
export const reqEpisodeComments = (episodeId, params = {}) => {
  validateId(episodeId, '集数ID')
  const defaultParams = {
    page: 1,
    pageSize: 20,
    sort: 'newest',
    showSpoilers: false
  }

  const finalParams = mergeParams(defaultParams, params)

  // 参数验证
  validateEnum(finalParams.sort, ['newest', 'hottest'], '排序方式')

  return http.get(`/api/episodes/${episodeId}/comments`, {
    params: finalParams
  })
}

// ==================== 交互操作API ====================

/**
 * 4. 单集视频点赞/取消点赞
 * @param {number|string} episodeId - 集数ID
 * @param {string} action - 操作类型：'like'点赞 或 'unlike'取消点赞
 * @returns {Promise} 返回操作结果和更新后的点赞状态
 */
export const toggleEpisodeLike = (episodeId, action) => {
  validateId(episodeId, '集数ID')
  validateAction(action, ['like', 'unlike'])
  return http.post(`/api/episodes/${episodeId}/like`, { action })
}

/**
 * 5. 单集视频收藏/取消收藏
 * @param {number|string} episodeId - 集数ID
 * @param {string} action - 操作类型：'favorite'收藏 或 'unfavorite'取消收藏
 * @returns {Promise} 返回操作结果和更新后的收藏状态
 */
export const toggleEpisodeFavorite = (episodeId, action) => {
  validateId(episodeId, '集数ID')
  validateAction(action, ['favorite', 'unfavorite'])
  return http.post(`/api/episodes/${episodeId}/favorite`, { action })
}

/**
 * 6. 电视剧追剧/取消追剧
 * @param {number|string} dramaId - 电视剧ID
 * @param {string} action - 操作类型：'follow'追剧 或 'unfollow'取消追剧
 * @returns {Promise} 返回操作结果和更新后的追剧状态
 */
export const toggleDramaFollow = (dramaId, action) => {
  validateId(dramaId, '电视剧ID')
  validateAction(action, ['follow', 'unfollow'])
  return http.post(`/api/dramas/${dramaId}/follow`, { action })
}

/**
 * 7. 获取电视剧所有集数列表（不分页）
 * @param {number|string} dramaId - 电视剧ID
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回电视剧所有集数的完整列表
 */
export const reqDramaAllEpisodes = (dramaId, params = {}) => {
  validateId(dramaId, '电视剧ID')
  return http.get(`/api/dramas/${dramaId}/episodes/all`, {
    params: handleEpisodesParams(params)
  })
}

/**
 * 15. 获取用户追剧列表
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回用户正在追的电视剧列表
 */
export const reqFollowingDramas = (params = {}) => {
  return http.get('/api/dramas/following', {
    params: handleFollowingParams(params)
  })
}

/**
 * 16. 获取有更新的追剧列表（快捷方法）
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回有新集更新的追剧列表
 */
export const reqUpdatedFollowingDramas = (params = {}) => {
  return reqFollowingDramas({ ...params, sort: 'update_time' })
}

/**
 * 17. 获取更新中的追剧列表（快捷方法）
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回正在更新中的追剧列表
 */
export const reqUpdatingFollowingDramas = (params = {}) => {
  return reqFollowingDramas({ ...params, status: 'updating' })
}

/**
 * 18. 获取已完结的追剧列表（快捷方法）
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回已完结的追剧列表
 */
export const reqCompletedFollowingDramas = (params = {}) => {
  return reqFollowingDramas({ ...params, status: 'completed' })
}

/**
 * 19. 获取分类电视剧集合
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回按分类组织的电视剧集合
 */
export const reqCategoryDramas = (params = {}) => {
  return http.get('/api/dramas/categories', {
    params: handleCategoryParams(params)
  })
}

/**
 * 20. 获取精选视频列表
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回精选视频列表
 */
export const reqFeaturedVideos = (params = {}) => {
  return http.get('/api/episodes/featured', {
    params: handleFeaturedParams(params)
  })
}

// ==================== 追剧相关API ====================

/**
 * 21. 追剧/取消追剧操作
 * @param {number|string} dramaId - 电视剧ID
 * @param {string} action - 操作类型：'follow'追剧 或 'unfollow'取消追剧
 * @returns {Promise} 返回操作结果和更新后的追剧状态
 */
export const reqToggleFollow = (dramaId, action) => {
  validateId(dramaId, '电视剧ID')
  validateAction(action, ['follow', 'unfollow'])
  return http.post(`/api/dramas/${dramaId}/follow`, { action })
}

/**
 * 22. 获取我的追剧列表
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回我的追剧列表
 */
export const reqMyFollowingList = (params = {}) => {
  return http.get('/api/user/following', {
    params: handleMyFollowingParams(params)
  })
}

// ==================== 浏览记录相关API ====================

/**
 * 23. 记录视频浏览
 * @param {Object} params - 浏览记录参数
 * @returns {Promise} 返回记录结果
 */
export const reqRecordBrowsing = (params) => {
  if (!params || !params.dramaId || !params.episodeId) {
    return Promise.reject(new Error('电视剧ID和集数ID不能为空'))
  }

  // 验证观看进度
  if (params.watchProgress !== undefined) {
    if (typeof params.watchProgress !== 'number' || params.watchProgress < 0 || params.watchProgress > 1) {
      return Promise.reject(new Error('观看进度必须是0-1之间的数字'))
    }
  }

  // 验证观看位置格式
  if (params.watchPosition !== undefined) {
    const timeRegex = /^\d{1,2}:\d{2}(:\d{2})?$/
    if (!timeRegex.test(params.watchPosition)) {
      return Promise.reject(new Error('观看位置格式不正确，应为"mm:ss"或"hh:mm:ss"'))
    }
  }

  return http.post('/api/user/browsing-history', params)
}

/**
 * 24. 获取浏览记录列表
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回浏览记录列表
 */
export const reqBrowsingHistory = (params = {}) => {
  return http.get('/api/user/browsing-history', {
    params: handleBrowsingHistoryParams(params)
  })
}

/**
 * 25. 获取用户点赞的电视剧列表
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回用户点赞的电视剧列表
 */
export const reqLikedDramas = (params = {}) => {
  return http.get('/api/user/liked-dramas', {
    params: handleLikedDramasParams(params)
  })
}

/**
 * 26. 删除单条浏览记录
 * @param {number|string} recordId - 浏览记录ID
 * @returns {Promise} 返回删除结果
 */
export const reqDeleteBrowsingRecord = (recordId) => {
  validateId(recordId, '浏览记录ID')
  return http.delete(`/api/user/browsing-history/${recordId}`)
}

/**
 * 27. 批量删除浏览记录
 * @param {Array<number|string>} recordIds - 浏览记录ID数组
 * @returns {Promise} 返回批量删除结果
 */
export const reqBatchDeleteBrowsingRecords = (recordIds) => {
  if (!recordIds || !Array.isArray(recordIds) || recordIds.length === 0) {
    return Promise.reject(new Error('浏览记录ID数组不能为空'))
  }

  // 验证数组中的每个ID
  const invalidIds = recordIds.filter((id) => !id || (typeof id !== 'string' && typeof id !== 'number'))
  if (invalidIds.length > 0) {
    return Promise.reject(new Error('浏览记录ID数组包含无效的ID'))
  }

  return http.delete('/api/user/browsing-history/batch', { data: { recordIds } })
}

/**
 * 28. 删除单个追剧
 * @param {number|string} dramaId - 电视剧ID
 * @returns {Promise} 返回删除结果
 */
export const reqDeleteFollowing = (dramaId) => {
  validateId(dramaId, '电视剧ID')
  return http.delete(`/api/user/following/${dramaId}`)
}

/**
 * 29. 批量删除追剧
 * @param {Array<number|string>} dramaIds - 电视剧ID数组
 * @returns {Promise} 返回批量删除结果
 */
export const reqBatchDeleteFollowing = (dramaIds) => {
  // 参数验证
  if (!dramaIds || !Array.isArray(dramaIds) || dramaIds.length === 0) {
    return Promise.reject(new Error('电视剧ID数组不能为空'))
  }

  // 验证数组中的每个ID - 修复验证逻辑
  const invalidIds = dramaIds.filter((id) => {
    const numId = Number(id)
    return !id || isNaN(numId) || numId <= 0
  })

  if (invalidIds.length > 0) {
    return Promise.reject(new Error('电视剧ID数组包含无效的ID'))
  }

  // 转换为数字类型，确保数据格式一致
  const normalizedIds = dramaIds.map((id) => Number(id))

  return http.delete('/api/user/following/batch', {
    data: { dramaIds: normalizedIds }
  })
}

/**
 * 30. 获取用户收藏列表
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回用户收藏的电视剧列表
 */
export const reqUserFavorites = (params = {}) => {
  return http.get('/api/user/favorites', {
    params: handleUserFavoritesParams(params)
  })
}

/**
 * 31. 批量删除收藏
 * @param {Array<Object>} favoriteItems - 收藏项目数组
 * @param {Array<Object>} favoriteItems - 要删除的收藏项目数组
 * @param {('drama'|'episode')} favoriteItems[].type - 收藏项目类型，只能是 'drama' 或 'episode'
 * @param {(string|number)} favoriteItems[].id - 收藏项目的唯一标识符
 * @returns {Promise<any>} 删除操作的Promise
 * @throws {Error} 当传入的参数为空、不是数组、数组为空时抛出错误
 * @throws {Error} 当数组中包含无效的项目（缺少type或id，或type值无效）时抛出错误
 * @example
 * // 删除多个收藏项目
 * reqBatchDeleteFavorites([
 *   { type: 'drama', id: '123' },
 *   { type: 'episode', id: 456 }
 * ]);
 *   @returns {Promise} 返回批量删除结果
 */
export const reqBatchDeleteFavorites = (favoriteItems) => {
  if (!favoriteItems || !Array.isArray(favoriteItems) || favoriteItems.length === 0) {
    return Promise.reject(new Error('收藏项目数组不能为空'))
  }

  // 验证数组中的每个项目
  const invalidItems = favoriteItems.filter(
    (item) =>
      !item ||
      !item.type ||
      !['drama', 'episode'].includes(item.type) ||
      !item.id ||
      (typeof item.id !== 'string' && typeof item.id !== 'number')
  )

  if (invalidItems.length > 0) {
    return Promise.reject(new Error('收藏项目数组包含无效的项目，每个项目必须包含有效的type和id'))
  }

  return http.delete('/api/user/favorites/batch', { data: { favoriteItems } })
}

/**
 * 32. 删除单个收藏
 * @param {string} type - 收藏类型：'drama'电视剧 或 'episode'单集
 * @param {number|string} id - 对应的ID（dramaId或episodeId）
 * @returns {Promise} 返回删除结果
 */
export const reqDeleteFavorite = (type, id) => {
  if (!type || !['drama', 'episode'].includes(type)) {
    return Promise.reject(new Error('收藏类型必须是 drama 或 episode'))
  }

  validateId(id, '收藏项目ID')
  return http.delete(`/api/user/favorites/${type}/${id}`)
}

// ==================== 主页标签数据相关API ====================

/**
 * 33. 获取主页标签数据（通用接口 - 扩展版）
 * @param {string} tabKey - 标签标识：'recommend'推荐/'ranking'排行榜/'newDrama'新剧/'classic'经典好剧
 * @param {Object} params - 查询参数（可选）
 * @returns {Promise} 返回对应标签的分类和数据
 */
export const reqHomeTabData = (tabKey, params = {}) => {
  const config = handleHomeTabParams(tabKey, params)
  return http.get(config.url, { params: config.params })
}

/**
 * 34. 获取主页分页数据（保留原接口）
 * @param {string} tabKey - 标签标识：'recommend'推荐/'ranking'排行榜/'newDrama'新剧/'classic'经典好剧
 * @param {Object} params - 查询参数
 * @returns {Promise} 返回分页数据
 */
export const reqHomePageData = (tabKey, params = {}) => {
  return reqHomeTabData(tabKey, { ...params, withPagination: true })
}

// ==================== 主页快捷方法（保留向后兼容性） ====================

/**
 * 35. 获取推荐标签数据（快捷方法）
 * @returns {Promise} 返回推荐标签的所有分类和数据
 */
export const reqRecommendTabData = () => {
  return reqHomeTabData('recommend')
}

/**
 * 36. 获取排行榜标签数据（快捷方法）
 * @returns {Promise} 返回排行榜标签的所有分类和数据
 */
export const reqRankingTabData = () => {
  return reqHomeTabData('ranking')
}

/**
 * 37. 获取新剧标签数据（快捷方法）
 * @returns {Promise} 返回新剧数据
 */
export const reqNewDramaTabData = () => {
  return reqHomeTabData('newDrama')
}

/**
 * 38. 获取经典好剧标签数据（快捷方法）
 * @returns {Promise} 返回经典好剧数据
 */
export const reqClassicTabData = () => {
  return reqHomeTabData('classic')
}

/**
 * 获取首页数据
 * @returns {Promise} 返回首页数据
 */
export const getHome = () => {
  return http.get('/api/home')
}

/**
 * 处理评论提交请求参数
 * @param {Object} params - 用户提供的评论参数
 * @returns {Object} 处理后的参数
 */
const handleCommentParams = (params = {}) => {
  if (!params.content) {
    throw new Error('评论内容不能为空')
  }

  // 评论内容字数限制检查
  if (params.content && params.content.length > 500) {
    throw new Error('评论内容不能超过500个字符')
  }

  // 如果提供了评分，验证范围
  if (params.rating !== undefined) {
    if (typeof params.rating !== 'number' || params.rating < 0 || params.rating > 10) {
      throw new Error('评分必须是0-10之间的数字')
    }
  }

  return params
}

/**
 * 提交电视剧评论
 * @param {number|string} dramaId - 电视剧ID
 * @param {Object} params - 评论参数
 * @param {string} params.content - 评论内容
 * @param {number} params.rating - 评分(0-10)，可选
 * @param {string} params.images - 评论图片，逗号分隔的URL字符串，可选
 * @param {boolean} params.spoiler - 是否包含剧透，可选
 * @returns {Promise} 返回提交结果
 */
export const reqSubmitDramaComment = (dramaId, params) => {
  validateId(dramaId, '电视剧ID')
  return http.post(`/api/dramas/${dramaId}/comments`, handleCommentParams(params))
}

/**
 * 提交单集评论
 * @param {number|string} episodeId - 集数ID
 * @param {Object} params - 评论参数
 * @param {string} params.content - 评论内容
 * @param {number} params.rating - 评分(0-10)，可选
 * @param {string} params.images - 评论图片，逗号分隔的URL字符串，可选
 * @param {boolean} params.spoiler - 是否包含剧透，可选
 * @returns {Promise} 返回提交结果
 */
export const reqSubmitEpisodeComment = (episodeId, params) => {
  validateId(episodeId, '集数ID')
  return http.post(`/api/episodes/${episodeId}/comments`, handleCommentParams(params))
}

/**
 * 回复评论
 * @param {number|string} commentId - 评论ID
 * @param {Object} params - 回复参数
 * @param {string} params.content - 回复内容
 * @param {string} params.replyTo - 回复的用户名，可选
 * @returns {Promise} 返回回复结果
 */
export const reqReplyToComment = (commentId, params) => {
  validateId(commentId, '评论ID')
  if (!params.content) {
    throw new Error('回复内容不能为空')
  }
  return http.post(`/api/comments/${commentId}/replies`, params)
}

/**
 * 评论点赞/取消点赞
 * @param {number|string} commentId - 评论ID
 * @param {string} action - 操作类型：'like'点赞 或 'unlike'取消点赞
 * @returns {Promise} 返回操作结果和更新后的点赞状态
 */
export const reqToggleCommentLike = (commentId, action) => {
  validateId(commentId, '评论ID')
  validateAction(action, ['like', 'unlike'])

  return http.post(`/api/comments/${commentId}/like`, { action })
}

/**
 * 删除评论
 * @param {number|string} commentId - 评论ID
 * @returns {Promise} 返回删除结果
 */
export const reqDeleteComment = (commentId) => {
  validateId(commentId, '评论ID')
  return http.delete(`/api/comments/${commentId}`)
}

/**
 * 获取评论回复列表
 * @param {number|string} commentId - 评论ID
 * @param {Object} params - 查询参数
 * @param {number} params.page - 页码，默认1
 * @param {number} params.pageSize - 每页数量，默认20
 * @returns {Promise} 返回评论回复列表
 */
export const reqCommentReplies = (commentId, params = {}) => {
  validateId(commentId, '评论ID')
  const defaultParams = {
    page: 1,
    pageSize: 20
  }
  return http.get(`/api/comments/${commentId}/replies`, {
    params: mergeParams(defaultParams, params)
  })
}
